/* ========================================================================= */
/* ------------------------------------------------------------------------- */
/*!
  \file			pgitlist.cc
  \date			Sep 2012
  \author		TNick

  \brief		Contains the implementation of PgItList class


*//*


 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Please read COPYING and README files in root folder
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
//
//
//
//
/*  INCLUDES    ------------------------------------------------------------ */

#include	<cpg/cpg.h>

#include	<2D/abox2d.h>

#include	<cpg/preferences/prefs.h>

#include	<cpg/logic/cpgdoc.h>
#include	<cpg/logic/pgspace.h>
#include	<cpg/logic/pglayer.h>
#include	<cpg/logic/pgitem.h>

#include	"pgitlist.h"


/*  INCLUDES    ============================================================ */
//
//
//
//
/*  DEFINITIONS    --------------------------------------------------------- */

using namespace cpg;

/*  DEFINITIONS    ========================================================= */
//
//
//
//
/*  DATA    ---------------------------------------------------------------- */

/*  DATA    ================================================================ */
//
//
//
//
/*  CLASS    --------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */
int					PgItList::appendUnique		( PgItem * new_it )
{
	int i = it_l.indexOf( new_it );
	if ( i == -1 )
	{
		it_l.append( new_it );
		return it_l.count() - 1;
	}
	return i;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
void				PgItList::appendUnique		( const PgItList & new_it )
{
	foreach( PgItem * itr, new_it.it_l )
	{
		if ( it_l.contains( itr ) == false )
		{
			it_l.append( itr );
		}
	}
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
bool				PgItList::remove				( PgItem * itm )
{
	int i = it_l.indexOf( itm );
	if ( i == -1 )
		return false;
	it_l.removeAt( i );
	return true;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
bool				PgItList::remove				( int i )
{
	if ( ( i < 0 ) || ( i > it_l.count() ) )
		return false;
	it_l.removeAt( i );
	return true;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
bool				PgItList::boundingBox			(
		ABOX2D & rct ) const
{

	int i;
	ABOX2D	bx_i;

	if ( it_l.count() == 0 )
	{
		rct.reset();
		return false;
	}
	it_l.at( 0 )->boundingBox( rct );
	int i_max = it_l.count();
	for ( i = 1; i < i_max; i++ )
	{
		it_l.at( i )->boundingBox( bx_i );
		rct.unite( bx_i );
	}
	return true;
}
/* ========================================================================= */


/* ------------------------------------------------------------------------- */
void				PgItList::translate			( P2D & displ )
{
	foreach( PgItem * itr, it_l  )	{
		itr->translate( displ.x_, displ.y_ );
	}
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
void				PgItList::translate			( qreal dx, qreal dy )
{
	foreach( PgItem * itr, it_l  )	{
		itr->translate( dx, dy );
	}
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
void				PgItList::scale				( P2D & base, qreal factor )
{
	foreach( PgItem * itr, it_l  )	{
		itr->scale( base, factor );
	}
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
void				PgItList::rotate			( P2D & base, qreal angle )
{
	foreach( PgItem * itr, it_l  )	{
		itr->rotate( base, angle );
	}
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
PgItem *			PgItList::itemAt			( const ABOX2D & rct ) const
{

	foreach( PgItem * itr, it_l )
	{
		if ( itr->visibleIn( rct ) )
		{
			return itr;
		}
	}
	return NULL;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
bool				PgItList::setProp				(
		PropIndex idx, const QString & value )
{
	Q_UNUSED( idx ); Q_UNUSED( value );
	/** @todo implement */
	bool b = true;
	foreach( PgItem * itr, it_l  )
	{
		Q_UNUSED( itr );
//		b = b & itr->setProp( idx, value );
	}
	return b;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
bool				PgItList::setProp				(
		PropIndex idx, qreal value )
{
	Q_UNUSED( idx ); Q_UNUSED( value );
	/** @todo implement */
	bool b = true;
	foreach( PgItem * itr, it_l )
	{
		Q_UNUSED( itr );
//		b = b & itr->setProp( idx, value );
	}
	return b;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
bool				PgItList::setProp				(
		PropIndex idx, int value )
{
	Q_UNUSED( idx ); Q_UNUSED( value );
	/** @todo implement */
	/* how about a template? QVariant? */
	bool b = true;
	foreach( PgItem * itr, it_l )
	{
		Q_UNUSED( itr );
//		b = b & itr->setProp( idx, value );
	}
	return b;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
QVariantList		PgItList::getProp				( PropIndex idx )
{
	Q_UNUSED( idx );
	/** @todo implement */
	QVariantList vl;
	foreach( PgItem * itr, it_l )
	{
		Q_UNUSED( itr );
//		QVariantList vl_in = itr->getProp( idx ) ;
//		QVL_unite( vl, vl_in );
	}
	return vl;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
void				PgItList::deleteAll			( void )
{
	foreach( PgItem * itr, it_l  )	{
		delete itr;
	}
	it_l.clear();
}
/* ========================================================================= */


/* ------------------------------------------------------------------------- */
void				PgItList::extract				( void )
{
	foreach( PgItem * itr, it_l  )	{
		itr->extract();
	}
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
void				PgItList::insert				( void )
{
	foreach( PgItem * itr, it_l  )	{
		itr->insert();
	}
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
PgSpace *			PgItList::space				( void )
{
	if ( it_l.count() == 0 )
		return NULL;

	PgSpace * sp = it_l.at( 0 )->space();
	foreach( PgItem * itr, it_l )
	{
		if ( sp != itr->space() )
		{
			return NULL;
		}
	}
	return sp;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
void				PgItList::clone			( PgItList & out ) const
{
	foreach( PgItem * itr, it_l )
	{
		out.append( itr->clone() );
	}
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
bool				PgItList::haveCommonItems	( const PgItList & other ) const
{
	if ( other.count() == 0 )
		return false;
	foreach( PgItem * itr, it_l )
	{
		if ( other.contains( itr ) )
		{
			return true;
		}
	}
	return false;
}
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
void				PgItList::asXML			(
		BBlocks::ByteBuffer * root ) const
{
	/*
	QDomDocument doc = root.ownerDocument();
	QDomElement x_it_l = doc.createElement( Prefs::getS( Prefs::XMLTAG_PGITEMS_LIST ) );
	root.appendChild( x_it_l );
	QDomElement it_entry;
	foreach( PgItem * itr, it_l )
	{
		it_entry = doc.createElement( Prefs::getS( Prefs::XMLTAG_PGITEM ) );
		x_it_l.appendChild( it_entry );

		itr->toXML( it_entry );
	}
	*/
	/** @todo asXML */
	Q_UNUSED( root );
}
/* ========================================================================= */



/*  CLASS    =============================================================== */
//
//
//
//
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
